import java.util.Scanner;

public class StringTest {
    /**
     * 字符串大小写转换
     */
    //法1
    public String toLowerCase(String s){
        StringBuilder stringbuilder = new StringBuilder();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if(ch >= 'A' && ch <= 'Z'){
                stringbuilder.append((char)(ch+32));//将计算结果转为字符，+32会进行隐式类型转化
            }else{
                stringbuilder.append(ch);
            }
        }
        return stringbuilder.toString();
    }
    //法2(可能会挨打）
    public String toLowerCase1(String s){
        String str = new String(s.toLowerCase());
        return str;
    }



    /**
     * 字符串中的单词数
     * 统计字符串中的单词数，这里的单词指的是来连续的不是空格的字符
     * 请注意，你可以假定字符串里不包含任何不可打印的字符
     */
    public static int countSegments(String s){
        s = s.trim();//去除两边空客
        String[] strings = s.split(" ");//可能有连续空格的情况，会分割出空字符串
        int count = 0;//计数器
        for (int i = 0; i < strings.length; i++) {
            if(!strings[i].equals("")){
                count++;//去除空字符串的结果
            }
        }
        return count;
    }
    //例子
    public static void main(String[] args) {
        System.out.println(countSegments(", , , ,        a, aswe"));
    }



    /**
     * 验证会文串
     * 给定一个字符串，验证它是否是会文串，只考虑字母和数字字符，可以忽略字母的大小写
     */

    //寻找数字字符或者字母（排除其他字符）
    public boolean isEffective(char ch){
        //法一
        if(Character.isLetter(ch) || Character.isDigit(ch)){
            return true;
        }
        return false;
        //法2
        //return Character.isLetterOrDigit(ch);//判断是不是数字符或者字母
    }

    public boolean isPalindrome(String s){
        //忽略大小写（任选其一)
        s = s.toLowerCase();//全部转化为小写字符
        //s = s.toUpperCase();//全部转化为大写字符

        int left = 0;
        int right = s.length()-1;
        while(left < right){
            //经过判断后left下标为有效字符
            while(left < right && isEffective(s.charAt(left))){
                left++;
            }
            //经过判断后right下标为有效字符
            while(left < right && isEffective(s.charAt(right))){
                right--;
            }

            if(s.charAt(left) != s.charAt(right)){
                return false;
            }
            left++;
            right--;
        }
        return true;
    }



    /**
     * 字符串最后一个的单词的长度
     * 计算字符串最后一个单词的长度，单词以空格隔开，字符串长度小于5000
     * （注：字符串末尾不以空格结尾）
     */
    //法一（split）
     public static int searchLastWord1() {
         Scanner scanner = new Scanner(System.in);
         String s = scanner.nextLine();
         String[] word = s.split(" ");
         int sLength = word.length - 1;
         return word[sLength].length();
     }

    //法2（lastIndexOf)
    public static int searchLastWord2(){
         Scanner scanner = new Scanner(System.in);
         String str = scanner.nextLine();
         int pos = str.lastIndexOf(" ");
         return str.length()-pos-1;
    }

    //法3（原始方法）
    public static int searchLastWord3(){
         Scanner scanner = new Scanner(System.in);
         String s = scanner.nextLine();
         int index = -1;
        for (int i = s.length()-1; i >= 0; i--) {
            if(s.charAt(i) == ' '){
                index = s.length()-1-i;
                break;
            }
        }
        return index;
    }



    /**
     字符串中的第一个唯一字符
     给定一个字符串s，找到它的第一个不重复的字符，并返回它的索引，。
     * 如果不存在，则返回-1
     */
    public int firstUniqChar(String s){
        int[] count = new int[26];
        //循环遍历字符串中的字符，在对应数组中+1
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            count[ch-'a']++;
        }
        //再次遍历字符串，根据count数组中的储存的数值，找到第一个唯一字符
        for (int i = 0; i < s.length(); i++) {
            if(count[s.charAt(i) - 'a'] == 1){
                return i;
            }
        }
        return -1;
    }
}
